# -*- coding: utf-8 -*-
 ##############################################
 ##                                            ##
 ##          View for Persons package           ##
 ##                                             ##
 ##                                             ##
 ##              from Basiq Series              ##
 ##           by Críptidos Digitales            ##
 ##                 GPL (c)2008                 ##
  ##                                            ##
    ##############################################

"""
"""

import sys
from PyQt4 import QtCore, QtGui

import frame_ui
import administrador_ui as administrador_ui
import captura_ui as captura_ui
import detalles_ui as detalles_ui

from cdWidgets.cdRfcEdit import CDRfcEdit


import model

class package:
    pass


class Forma(QtGui.QFrame):

    def __init__(self, *args, **kwds):
        args = list(args)
        try:
            package.rolType = args.pop(0)
            if package.rolType == u'proveedores':
                package.rolTypeS = u'proveedor'
            elif package.rolType == u'empleados':
                package.rolTypeS = u'empleado'
            elif package.rolType == u'clientes':
                package.rolTypeS = u'cliente'

        except:
            print "Big mistake, missing rol type calling person view"

        if kwds.has_key('owner'):
            self.__owner = kwds.pop('owner')
        else:
            self.__owner = None

        QtGui.QFrame.__init__(self, *args)

        self.ui = frame_ui.Ui_Form()
        self.ui.setupUi(self)

        self.ui.frame1.close()
        self.ui.frame2.close()
        self.ui.frame3.close()

        ## Detalles
        self.detalles = Detalles(self)
        self.detalles.hide()
        self.detalles.status = 'normal'

        ## Captura
        self.captura = Captura(self)
        self.connect(self.captura, QtCore.SIGNAL('changed()'), self.changed)
        self.connect(self.captura, QtCore.SIGNAL('capturaClosed()'), self.capturaClosed)
        self.captura.hide()

        ## Administrador
        self.administrador = Administrador(self)
        self.connect(self.administrador, QtCore.SIGNAL('changed()'), self.changed)
        self.connect(self.administrador, QtCore.SIGNAL('personSelected(int)'), self.personSelected)

        self.ui.outerSplitter = Splitter(QtCore.Qt.Vertical, self)
        ## InnerSplitter
        self.ui.innerSplitter = Splitter(QtCore.Qt.Horizontal, self.ui.outerSplitter)
        self.ui.innerSplitter.insertWidget(0, self.administrador)
        self.ui.innerSplitter.insertWidget(1, self.detalles)
        self.connect(self.ui.innerSplitter.handle(1), QtCore.SIGNAL('handlePressed'), self.innerHandlePressed)
        self.ui.innerSplitter.setSizes([1, 1])

        ## OuterSplitter
        self.ui.outerSplitter.insertWidget(0, self.ui.innerSplitter)
        self.ui.outerSplitter.insertWidget(1, self.captura)
        # self.ui.outerSplitter.setStyleSheet("QSplitter::handle{background-color:#FFFF00}")

        self.connect(self.ui.outerSplitter.handle(1), QtCore.SIGNAL('handlePressed'), self.outerHandlePressed)
        self.ui.outerSplitter.setSizes([1, 1])
        self.ui.verticalLayout.addWidget(self.ui.outerSplitter)


    def personSelected(self, id):
        if self.detalles.isVisible():
            if self.detalles.id == id:
                self.detalles.hide()
        else:
            self.detalles.mostrar(id)
            # self.detalles.show()

    def capturaClosed(self):
        self.setInnerStatus("visible")
        self.administrador.actualizaBotones()

    def changed(self):
        self.emit(QtCore.SIGNAL('changed()'))

    def innerHandlePressed(self):
        self.toggleDetalles()

    def outerHandlePressed(self):
        if self.ui.outerSplitter.sizes()[0] == 0:
            self.setInnerStatus('visible')
        else:
            self.setInnerStatus('hidden')

    def setInnerStatus(self, value):
        if value == 'visible':
            self.administrador.show()
            if self.detalles.status == 'hidden':
                self.detalles.show()
                self.detalles.status = "normal"

        elif value == 'hidden':
            self.administrador.hide()
            if self.detalles.isVisible():
                self.detalles.status = "hidden"
                self.detalles.hide()

        elif value == 'disabled':
            print 'disables'

    def toggleDetalles(self, *args):
        if self.detalles.isVisible():
            self.detalles.hide()
        else:
            self.detalles.show()
            if self.administrador.ui.tablaConsulta.currentRow() != -1:
                id = self.administrador.ui.tablaConsulta.item(self.administrador.ui.tablaConsulta.currentRow(), 0).data(1000).toInt()[0]
                self.detalles.mostrar(id)



class Administrador(QtGui.QFrame):

    def __init__(self, *args, **kwds):
        self.owner = args[0]

        QtGui.QFrame.__init__(self, *args)

        self.ui = administrador_ui.Ui_Form()
        self.ui.setupUi(self)

        ## TABLA DE CONSULTA
        self.ui.tablaConsulta.setShowGrid(True)
        self.ui.tablaConsulta.setSelectionMode(QtGui.QAbstractItemView.SingleSelection)
        self.ui.tablaConsulta.setSelectionBehavior(QtGui.QAbstractItemView.SelectRows)
        self.ui.tablaConsulta.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
        if package.rolType == u'proveedores':
            self.ui.tablaConsulta.setToolTip(u"Doble clic en un renglón muestra los detalles del Proveedor\n\nPresionar el botón derecho muestra las acciones pertinentes")
            self.ui.tablaConsulta.columnLabels = [u"Nombre", u"RFC", u"Teléfono", u"Lugar", u"Domicilio"]
            self.ui.tablaConsulta.setColumnCount(len(self.ui.tablaConsulta.columnLabels))
            self.ui.tablaConsulta.setHorizontalHeaderLabels(self.ui.tablaConsulta.columnLabels)
        elif package.rolType == u'empleados':
            self.ui.tablaConsulta.setToolTip(u"Doble clic en un renglón muestra los detalles del Empleado\n\nPresionar el botón derecho muestra las acciones pertinentes")
            self.ui.tablaConsulta.columnLabels = [u"Nombre", u"RFC", u"Puesto", u"Teléfono", u"Lugar", u"Domicilio"]
            self.ui.tablaConsulta.setColumnCount(len(self.ui.tablaConsulta.columnLabels))
            self.ui.tablaConsulta.setHorizontalHeaderLabels(self.ui.tablaConsulta.columnLabels)
        elif package.rolType == u'clientes':
            self.ui.tablaConsulta.setToolTip(u"Doble clic en un renglón muestra los detalles del Cliente\n\nPresionar el botón derecho muestra las acciones pertinentes")
            self.ui.tablaConsulta.columnLabels = [u"Nombre", u"RFC", u"Teléfono", u"Lugar", u"Domicilio"]
            self.ui.tablaConsulta.setColumnCount(len(self.ui.tablaConsulta.columnLabels))
            self.ui.tablaConsulta.setHorizontalHeaderLabels(self.ui.tablaConsulta.columnLabels)

        # self.connect(self.ui.tablaConsulta, QtCore.SIGNAL("itemDoubleClicked(QTableWidgetItem *)"), self.owner.toggleDetalles)
        self.connect(self.ui.tablaConsulta, QtCore.SIGNAL("itemDoubleClicked(QTableWidgetItem *)"), self.itemSelected)
        self.connect(self.ui.tablaConsulta, QtCore.SIGNAL("itemSelectionChanged()"), self.selectionChanged)
        self.connect(self.ui.tablaConsulta, QtCore.SIGNAL("resized(QEvent)"), self.resizedTablaConsulta)
        self.connect(self.ui.tablaConsulta, QtCore.SIGNAL("customContextMenuRequested(QPoint)"), self.mostrarMenuConsulta)

        ## Agregar
        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Plus.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.aAgregar = QtGui.QAction(icon, u"&Agregar", self)
        self.aAgregar.setCheckable(True)
        self.aAgregar.setIconText(u"&Agregar")
        self.connect(self.aAgregar, QtCore.SIGNAL("triggered()"), self.agrega)

        self.ui.toAgregar.setDefaultAction(self.aAgregar)
        self.ui.toAgregar.setIconSize(QtCore.QSize(44, 40))
        self.ui.toAgregar.setToolButtonStyle(QtCore.Qt.ToolButtonTextUnderIcon)

        ## Modificar
        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Redo.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.aModificar = QtGui.QAction(icon, u"&Modificar", self)
        self.aModificar.setCheckable(True)
        self.aModificar.setIconText(u"&Modificar")
        self.connect(self.aModificar, QtCore.SIGNAL("triggered()"), self.modifica)

        self.ui.toModificar.setDefaultAction(self.aModificar)
        self.ui.toModificar.setIconSize(QtCore.QSize(44, 40))
        self.ui.toModificar.setToolButtonStyle(QtCore.Qt.ToolButtonTextUnderIcon)

        ## Eliminar
        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Minus.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.aEliminar = QtGui.QAction(icon, u"&Eliminar", self)
        self.aEliminar.setCheckable(True)
        self.aEliminar.setIconText(u"&Eliminar")
        self.connect(self.aEliminar, QtCore.SIGNAL("triggered()"), self.eliminar)

        self.ui.toEliminar.setDefaultAction(self.aEliminar)
        self.ui.toEliminar.setIconSize(QtCore.QSize(44, 40))
        self.ui.toEliminar.setToolButtonStyle(QtCore.Qt.ToolButtonTextUnderIcon)

        if package.rolType == u'proveedores':
            self.ui.toEliminar.hide()

        ## Imprimir
        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Print.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.aImprimir = QtGui.QAction(icon, u"Imprimir", self)
        self.aImprimir.setIconText(u"&Imprimir")
        self.connect(self.aImprimir, QtCore.SIGNAL("triggered()"), self.imprime)

        self.ui.toImprimir.setDefaultAction(self.aImprimir)
        self.ui.toImprimir.setIconSize(QtCore.QSize(44, 40))
        self.ui.toImprimir.setToolButtonStyle(QtCore.Qt.ToolButtonTextUnderIcon)

        ## Menu
        self.menuTablaConsulta = QtGui.QMenu(self)
        self.menuTablaConsulta.addAction(self.aAgregar)
        self.menuTablaConsulta.addAction(self.aModificar)
        self.menuTablaConsulta.addAction(self.aEliminar)

        self.connect(session.eventRouter, QtCore.SIGNAL('proveedoresChanged()'), self.actualizaConsulta)
        self.connect(session.eventRouter, QtCore.SIGNAL('empleadosChanged()'), self.actualizaConsulta)
        self.connect(session.eventRouter, QtCore.SIGNAL('clientesChanged()'), self.actualizaConsulta)

        self.impresor = QtGui.QPrinter()

        self.actualizaConsulta()

        self.ui.tablaConsulta.sortItems(0, QtCore.Qt.AscendingOrder)


    def actualizaBotones(self):
        self.aAgregar.setEnabled(True)
        self.aAgregar.setToolTip(u"Presiona para registrar un %s nuevo" % package.rolTypeS)

        if not self.owner.captura.isVisible():
            self.aAgregar.setChecked(False)
            self.aModificar.setChecked(False)
        self.aEliminar.setChecked(False)

        if self.ui.tablaConsulta.rowCount() == 0:
            self.aModificar.setEnabled(False)
            self.aEliminar.setEnabled(False)
            self.aImprimir.setEnabled(False)
            self.aModificar.setToolTip(u"No hay %s registrados" % package.rolType)
            self.aEliminar.setToolTip(u"No hay %s registrados" % package.rolType)
            self.aImprimir.setToolTip(u"No hay %s registrados" % package.rolType)
        else:
            self.aImprimir.setEnabled(True)
            self.aImprimir.setToolTip(u"Se imprimen los %s listados solamente" % package.rolType)
            if self.ui.tablaConsulta.currentRow() == -1:
                self.aModificar.setEnabled(False)
                self.aModificar.setToolTip(u"Selecciona el %s que quieres modificar" % package.rolTypeS)
                self.aEliminar.setEnabled(False)
                self.aEliminar.setToolTip(u"Selecciona el %s que quieres eliminar" % package.rolTypeS)
            else:
                id = self.ui.tablaConsulta.item(self.ui.tablaConsulta.currentRow(), 0).data(1000).toInt()[0]

                if package.rolType == u'empleados':
                    if id == 2:
                        self.aModificar.setEnabled(False)
                        self.aModificar.setToolTip(u"Este empleado no se puede modificar")
                    else:
                        self.aModificar.setEnabled(True)
                        self.aModificar.setToolTip(u"Presiona para modificar los datos del Empleado seleccionado")

                    empleados = modelo.rolesI(tipo=package.rolTypeS, funcion=u'Administrador')
                    if len(empleados) == 1:
                        self.aEliminar.setEnabled(False)
                        self.aEliminar.setToolTip(u"No se puede eliminar al único Administrador")
                    else:
                        self.aEliminar.setEnabled(True)
                        self.aEliminar.setToolTip(u"Presiona para eliminar el Empleado seleccionado")
                else:
                    if id == 1:
                        nombre = self.ui.tablaConsulta.item(self.ui.tablaConsulta.currentRow(), 0).text()
                        self.aModificar.setEnabled(False)
                        self.aModificar.setToolTip(u"No se pueden modificar los datos de %s" %nombre)
                        self.aEliminar.setEnabled(False)
                        self.aEliminar.setToolTip(u"No se puede eliminar el Cliente %s" % nombre)
                    else:
                        self.aModificar.setEnabled(True)
                        self.aModificar.setToolTip(u"Presiona para modificar los datos del %s seleccionado" % package.rolTypeS)
                        self.aEliminar.setEnabled(True)
                        self.aEliminar.setToolTip(u"Presiona para eliminar el %s seleccionado" % package.rolTypeS)

                self.aImprimir.setEnabled(True)
                self.aImprimir.setToolTip(u"Presiona para Imprimir los %s enlistados" % package.rolType)


    def actualizaConsulta(self):

        session.mainForm.setCursor(QtCore.Qt.WaitCursor)

        old = self.currentId()

        roles = model.getRoles(tipo=package.rolTypeS)


        self.ui.tablaConsulta.setRowCount(0)
        self.ui.tablaConsulta.setSortingEnabled(False)

        for rowIndex, rol in enumerate(roles):


            self.ui.tablaConsulta.insertRow(rowIndex)

            item = QtGui.QTableWidgetItem("%s %s" % (rol['nombre'], rol['nombre2']))
            item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
            item.setData(1000, QtCore.QVariant(rol['id']))
            self.ui.tablaConsulta.setItem(rowIndex, 0, item)

            item = QtGui.QTableWidgetItem(rol['rfc'])
            item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
            self.ui.tablaConsulta.setItem(rowIndex, self.ui.tablaConsulta.columnLabels.index(u'RFC'), item)

            ## Contactos
            rolAttributes = model.getRolAttributes(rol_id=rol['id'])
            telFijoZero = [x for x in rolAttributes if x['nombre']==u'tel fijo']
            if telFijoZero:
                item = QtGui.QTableWidgetItem(telFijoZero[0]['valor'])
            else:
                item = QtGui.QTableWidgetItem(u"")
            item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
            self.ui.tablaConsulta.setItem(rowIndex, self.ui.tablaConsulta.columnLabels.index(u'Teléfono'), item)

            ## Funciones
            if package.rolType == u'empleados':
                funciones = u""
                for rowIndex2, funcion in enumerate([x for x in dato.atributos if x.nombre==u'función']):
                    if rowIndex2:
                        funciones += ", %s" % funcion.valor
                    else:
                        funciones += funcion.valor
                item = QtGui.QTableWidgetItem(funciones)
                item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
                self.ui.tablaConsulta.setItem(rowIndex, self.ui.tablaConsulta.columnLabels.index(u'Puesto'), item)

            ## Direcciones
            direcciones = model.addresses(rol_id=rol['id'])

            if direcciones:
                item = QtGui.QTableWidgetItem(direcciones[0]['lugar'])
                item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))

                item2 = QtGui.QTableWidgetItem("%s, %s" % (direcciones[0]['calle'], direcciones[0]['areanominal']))
                item2.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
                self.ui.tablaConsulta.setItem(rowIndex, self.ui.tablaConsulta.columnLabels.index(u'Lugar'), item)

                self.ui.tablaConsulta.setItem(rowIndex, self.ui.tablaConsulta.columnLabels.index(u'Domicilio'), item2)

        self.ui.tablaConsulta.setSortingEnabled(True)

        self.setCurrentId(old)

        self.actualizaBotones()

        session.mainForm.setCursor(QtCore.Qt.ArrowCursor)


    def agrega(self):
        self.owner.captura.agrega()


    def currentId(self):
        if self.ui.tablaConsulta.currentRow() != -1:
            id = self.ui.tablaConsulta.item(self.ui.tablaConsulta.currentRow(), 0).data(1000).toInt()[0]
        else:
            id = None
        return id


    def eliminar(self):
        if self.ui.tablaConsulta.currentRow() < 0:
            result = QtGui.QMessageBox.information(self, u"Empresa Básica - Eliminar %s" % package.rolTypeS, u"Selecciona el %s que quieres ELIMINAR" % package.rolTypeS, QtGui.QMessageBox.Ok, QtGui.QMessageBox.Ok)
        else:
            id = self.ui.tablaConsulta.item(self.ui.tablaConsulta.currentRow(), 0).data(1000).toInt()[0]
            rol = model.getRol(id=id)

            result = QtGui.QMessageBox.warning(self, u"Empresa Básica - Eliminar %s" % package.rolTypeS, u"¿Realmente quieres ELIMINAR el %s %s %s?" % (package.rolTypeS, rol['nombre'], rol['nombre2']), QtGui.QMessageBox.Yes | QtGui.QMessageBox.No, QtGui.QMessageBox.No)

            if result == QtGui.QMessageBox.Yes:
                model.elimina(id=id)
                self.emit(QtCore.SIGNAL("changed()"))


    def findData(self, data):
        index = -1
        for row in range(self.ui.tablaConsulta.rowCount()):
            if self.ui.tablaConsulta.item(row, 0).data(1000)==QtCore.QVariant(data):
                index = row
        return index


    def imprime(self):
        dialogoImpresora = QtGui.QPrintDialog(self.impresor)
        if dialogoImpresora.exec_() == QtGui.QDialog.Accepted:
            painter = QtGui.QPainter(self.impresor)
            margenHorizontal, margenVertical = [10, 10]

            font1 = QtGui.QFont("courier", 10)
            font1.setBold(True)
            font2 = QtGui.QFont("courier", 9)
            font3 = QtGui.QFont("Courier", 12)
            font3.setBold(True)

            margenX, margenY = [25, 75]
            pageWidth, pageHeight = (self.impresor.paperRect().width(), self.impresor.paperRect().height())
            pageNo = 1

            ## HEADER
            header = []
            x, y = [25, 0]
            header.append([pageWidth/2-100, margenY+y, u"Catálogo de %s" % package.rolType, font3])
            x, y = [400, 25]
            header.append([pageWidth-200, margenY+y, u"Fecha: %s" % QtCore.QDate().currentDate().toString('dd MMM yyyy'), font1])

            tabla = self.ui.tablaConsulta

            x, y = [0, 75]
            contenido = []
            footer = []
            offset = 0
            for row in range(tabla.rowCount()):
                if offset == 0:
                    contenido.extend(header)
                posX, posY = (margenX + x, margenY + y + offset)
                contenido.append([posX    , posY, str(row+1), font2])
                contenido.append([posX+40 , posY, tabla.item(row, 0).text(), font2])    # Nombre
                contenido.append([posX+90 , posY+18, tabla.item(row, 4).text(), font2]) # Domicilio
                contenido.append([posX+90 , posY+36, tabla.item(row, 3).text(), font2]) # Lugar
                contenido.append([posX+90 , posY+54, u"RFC: %s   Teléfonos: %s" % (tabla.item(row, 1).text(), tabla.item(row, 2).text()), font2]) # RFC, Teléfono
                # if tabla.item(row, 5):
                    # contenido.append([posX+690, posY, tabla.item(row, 5).text(), font2])# Importe
                offset += 80
                if posY+190 >= pageHeight:
                    contenido.append([pageWidth/2-50, pageHeight-50, "Hoja %s" % pageNo, font2])
                    for item in contenido:
                        painter.setFont(item[3])
                        painter.drawText(QtCore.QPoint(margenHorizontal + item[0], margenVertical + item[1]), item[2])
                    offset = 0
                    contenido = []
                    footer = []
                    pageNo += 1
                    self.impresor.newPage()

            contenido.append([pageWidth/2-50, pageHeight-50, "Hoja %s" % pageNo, font2])
            for item in contenido:
                painter.setFont(item[3])
                painter.drawText(QtCore.QPoint(margenHorizontal + item[0], margenVertical + item[1]), item[2])


    def itemSelected(self, item):
        id = self.ui.tablaConsulta.item(self.ui.tablaConsulta.currentRow(), 0).data(1000).toInt()[0]
        self.emit(QtCore.SIGNAL('personSelected(int)'), id)


    def modifica(self):
        if self.ui.tablaConsulta.currentRow() < 0:
            result = QtGui.QMessageBox.information(self, u"Empresa Básica - Modificar %s" % package.rolTypeS, u"Selecciona el %s que quieres MODIFICAR" % package.rolTypeS, QtGui.QMessageBox.Ok, QtGui.QMessageBox.Ok)
        else:
            id = self.ui.tablaConsulta.item(self.ui.tablaConsulta.currentRow(), 0).data(1000).toInt()[0]
            self.owner.captura.modifica(id)


    def mostrarMenuConsulta(self, pos):
        pos = self.ui.tablaConsulta.mapToGlobal(pos)
        self.menuTablaConsulta.popup(pos)


    def resizedTablaConsulta(self, event):
        headerWidth = self.ui.tablaConsulta.width()-self.ui.tablaConsulta.verticalHeader().width()-self.ui.tablaConsulta.verticalScrollBar().width()
        if headerWidth > 0:
            self.ui.tablaConsulta.horizontalHeader().setMinimumWidth(headerWidth)

        if package.rolType == u'proveedores':
            porcentajes = [25, 15, 19, 15, 25]
        elif package.rolType == u'empleados':
            porcentajes = [23, 15, 11, 17, 12, 21]
        elif package.rolType == u'clientes':
            porcentajes = [25, 15, 19, 15, 25]

        overflow = 0
        for index in range(self.ui.tablaConsulta.horizontalHeader().count()):

            self.ui.tablaConsulta.resizeColumnToContents(index)

            porContenido = self.ui.tablaConsulta.columnWidth(index)
            calculado = headerWidth * porcentajes[index] / 100

            if porContenido < calculado:
                if overflow:
                    offset = calculado - porContenido
                    if offset > overflow:
                        calculado = calculado - overflow
                        overflow = 0
                    else:
                        overflow -= offset
                        calculado = porContenido
                self.ui.tablaConsulta.setColumnWidth(index, calculado)
            else:
                overflow += porContenido - calculado


    def selectionChanged(self):
        if self.ui.tablaConsulta.currentRow() != -1:
            id = self.ui.tablaConsulta.item(self.ui.tablaConsulta.currentRow(), 0).data(1000).toInt()[0]
            if self.owner.detalles.isVisible():
                self.owner.detalles.mostrar(id)

            # if self.owner.captura.isVisible():
                # if self.owner.captura.modo == 'modificar':
                    # if self.owner.captura.id != id:
                        # if self.owner.captura.estaModificado():
                            # result = QtGui.QMessageBox.warning(self, u"Empresa Básica - Modificación de %s" % self.owner.tipo2, u"La captura de %s tiene cambios\n\n¿Quieres Guardar los cambios para %s %s?" % (self.owner.tipo2, self.owner.captura.old.entidad.nombre, self.owner.captura.old.entidad.nombre2), QtGui.QMessageBox.Yes | QtGui.QMessageBox.No, QtGui.QMessageBox.No)
                            # if result == QtGui.QMessageBox.Yes:
                                # self.owner.captura.guarda(hide=False)
                        # self.owner.captura.modifica(id)

        self.actualizaBotones()


    def setCurrentId(self, id):
        self.ui.tablaConsulta.setCurrentItem(self.ui.tablaConsulta.item(self.findData(id), 0))



class Captura(QtGui.QFrame):

    @property
    def modo(self):
        return self.__modo

    def __init__(self, *args):
        self.owner = args[0]

        self.__modo = None

        QtGui.QFrame.__init__(self, *args)

        self.ui = captura_ui.Ui_Form()
        self.ui.setupUi(self)

        self.ui.frame.setStyleSheet("QFrame{background-color:#E0E0E0;}")
        # self.connect(self.ui.frame, QtCore.SIGNAL('returnPressed()'), self.returnPressed)

        font = QtGui.QFont()
        font.setPointSize(9)
        font.setBold(True)

        self.ui.titulo.setFont(font)
        self.ui.titulo.setStyleSheet("background-color:#FFFFC0;")

        self.ui.frIdentidad.setStyleSheet("QFrame{background-color:#FFFFC0;}")
        self.ui.frDireccion.setStyleSheet("QFrame{background-color:#FFFFC0;}")
        self.ui.frContactos.setStyleSheet("QFrame{background-color:#FFFFC0;}")

        if package.rolType == u'proveedores':
            background = '#60D060'
        elif package.rolType == u'empleados':
            background = '#E0E040'
        elif package.rolType == u'clientes':
            background = '#80C0C0'

        self.status = 'init'
        self.old = None

        ## Nombre
        self.ui.laNombre.setFont(font)
        self.ui.laNombre.setStyleSheet("color:#FFFFFF; background-color:%s;" % background)

        self.ui.edNombre.setFont(font)
        self.ui.edNombre.setAllowedLengths(3, 50)
        self.ui.edNombre.setCapitalized(True)
        self.ui.edNombre.setPrefijoMensaje(u"El nombre")
        self.connect(self.ui.edNombre, QtCore.SIGNAL('textEdited(QString)'), self.nombreEditado)

        ## Apellidos
        self.ui.laApellidos.setFont(font)
        self.ui.laApellidos.setStyleSheet("color:#FFFFFF; background-color:%s;" % background)

        self.ui.edApellidos.setAllowedLengths(3, 30)
        self.ui.edApellidos.setCapitalized(True)
        self.ui.edApellidos.setEmptyAllowed(True)
        self.ui.edApellidos.setPrefijoMensaje(u"El apellido")
        self.connect(self.ui.edApellidos, QtCore.SIGNAL('textEdited(QString)'), self.nombre2Editado)

        ## Calle
        self.ui.laCalle.setFont(font)
        self.ui.laCalle.setStyleSheet("color:#FFFFFF; background-color:%s;" % background)

        self.ui.edCalle.setAllowedLengths(0, 40)
        self.connect(self.ui.edCalle, QtCore.SIGNAL('textEdited(QString)'), self.actualizaStatus)

        ## Colonia
        self.ui.laColonia.setFont(font)
        self.ui.laColonia.setStyleSheet("color:#FFFFFF; background-color:%s;" % background)

        self.ui.edColonia.setAllowedLengths(0, 40)
        self.ui.edColonia.setEmptyAllowed(True)
        self.connect(self.ui.edColonia, QtCore.SIGNAL('textEdited(QString)'), self.actualizaStatus)

        ## Código postal
        self.ui.laCodigoPostal.setFont(font)
        self.ui.laCodigoPostal.setStyleSheet("color:#FFFFFF; background-color:%s;" % background)

        self.ui.edCodigoPostal.setAllowedLengths(5, 5)
        self.ui.edCodigoPostal.setOnlyNumbers(True)
        self.ui.edCodigoPostal.setEmptyAllowed(True)
        self.ui.edCodigoPostal.setPrefijoMensaje(u"Código postal")
        self.connect(self.ui.edCodigoPostal, QtCore.SIGNAL('textEdited(QString)'), self.actualizaStatus)

        ## Lugar
        self.ui.laLugar.setFont(font)
        self.ui.laLugar.setStyleSheet("color:#FFFFFF; background-color:%s;" % background)
        font = QtGui.QFont()
        font.setPointSize(10)
        font.setBold(True)
        self.ui.cbLugar.lineEdit().setFont(font)

        self.ui.cbLugar.completer().setCompletionMode(QtGui.QCompleter.PopupCompletion)
        self.connect(self.ui.cbLugar, QtCore.SIGNAL('currentIndexChanged(int)'), self.lugarChanged)
        self.connect(self.ui.cbLugar, QtCore.SIGNAL('editTextChanged(QString)'), self.lugarEdited)
        self.connect(self.ui.cbLugar, QtCore.SIGNAL('lostFocus()'), self.lugarLostFocus)
        self.cargaLugares()

        ## RFC
        self.ui.laRFC.setFont(font)
        self.ui.laRFC.setStyleSheet("color:#FFFFFF; background-color:%s;" % background)

        self.ui.edRFC.setEmptyAllowed(False)

        self.connect(self.ui.edRFC, QtCore.SIGNAL('textEdited(QString)'), self.revisaRFC)

        ## Teléfonos
        self.ui.laTelefonos.setFont(font)
        self.ui.laTelefonos.setStyleSheet("color:#FFFFFF; background-color:%s;" % background)

        self.ui.edTelefonos.setAllowedLengths(0, 60)
        self.connect(self.ui.edTelefonos, QtCore.SIGNAL('textEdited(QString)'), self.actualizaStatus)

        ## Clasificacion
        self.ui.laClasificacion.setFont(font)
        self.ui.laClasificacion.setStyleSheet("color:#FFFFFF; background-color:%s;" % background)

        if package.rolType == u'proveedores':
            self.ui.frClasificacion.hide()
        elif package.rolType == u'empleados':
            self.ui.frClasificacion.hide()
        elif package.rolType == u'clientes':
            self.ui.frClasificacion.hide()

        ## Agentes
        self.ui.laAgentes.setFont(font)
        self.ui.laAgentes.setStyleSheet("color:#FFFFFF; background-color:%s;" % background)

        if package.rolType == u'proveedores':
            self.ui.edAgentes.setAllowedLengths(2, 60)
            self.ui.edAgentes.setEmptyAllowed(True)
            self.connect(self.ui.edAgentes, QtCore.SIGNAL('textEdited(QString)'), self.actualizaStatus)
        elif package.rolType == u'empleados':
            self.ui.frAgentes.hide()
        elif package.rolType == u'clientes':
            self.ui.edAgentes.setAllowedLengths(2, 60)
            self.ui.edAgentes.setEmptyAllowed(True)
            self.connect(self.ui.edAgentes, QtCore.SIGNAL('textEdited(QString)'), self.actualizaStatus)

        ## Puesto
        self.ui.laPuesto.setFont(font)
        self.ui.laPuesto.setStyleSheet("color:#FFFFFF; background-color:%s;" % background)
        self.ui.cbPuesto1.setFont(font)

        if package.rolType == u'proveedores':
            self.ui.puestoFR_layout.hide()
        elif package.rolType == u'empleados':
            # completer = QtGui.QCompleter([], self.ui.edPuesto)
            # completer.setCaseSensitivity(QtCore.Qt.CaseInsensitive)
            # self.ui.edPuesto.setCompleter(completer)
            # self.connect(completer, QtCore.SIGNAL("activated(QModelIndex)"), self.puestoSeleccionado)
            # self.connect(self.ui.edPuesto, QtCore.SIGNAL('downArrowPressed()'), self.muestraPuestos)
            # self.connect(self.ui.edPuesto, QtCore.SIGNAL('gotFocus()'), self.puestoGotFocus)
            self.cargaPuestos()
        elif package.rolType == u'clientes':
            self.ui.puestoFR_layout.hide()

        self.ui.cbPuesto2.setFont(font)
        self.ui.cbPuesto2.hide()
        self.ui.cbPuesto3.setFont(font)
        self.ui.cbPuesto3.hide()

        self.connect(self.ui.cbPuesto1, QtCore.SIGNAL('activated(int)'), self.actualizaStatus)
        self.connect(self.ui.cbPuesto2, QtCore.SIGNAL('activated(int)'), self.actualizaStatus)
        self.connect(self.ui.cbPuesto3, QtCore.SIGNAL('activated(int)'), self.actualizaStatus)
        self.connect(self.ui.boAgregarPuesto, QtCore.SIGNAL('clicked()'), self.agregaPuesto)


        ## Cuentas
        self.ui.laCuentas.setFont(font)
        self.ui.laCuentas.setStyleSheet("color:#FFFFFF; background-color:%s;" % background)
        if package.rolType == u'proveedores':
            pass
        elif package.rolType == u'empleados':
            self.ui.frCuentas.hide()
        elif package.rolType == u'clientes':
            pass

        ## EXTRAS
        if package.rolType == u'proveedores':
            pass
        elif package.rolType == u'empleados':
            self.ui.extrasFR.hide()
        elif package.rolType == u'clientes':
            self.ui.extrasFR.hide()

        ## Comentarios
        self.ui.comentarios.show()
        self.ui.boComentarios.status = 'on'
        self.connect(self.ui.boComentarios, QtCore.SIGNAL('clicked()'), self.toggleComentarios)
        # icon = QtGui.QIcon()
        # icon.addPixmap(QtGui.QPixmap("imagenes/Info.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        # self.ui.toComentarios.setIcon(icon)
        # self.ui.toComentarios.setIconSize(QtCore.QSize(32,32))
        # self.ui.toComentarios.setText(u"Ocultar información")
        # self.ui.toComentarios.status = 'on'
        # self.connect(self.ui.toComentarios, QtCore.SIGNAL('clicked()'), self.toggleComentarios)

        ## Guardar
        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Check.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.ui.boGuardar.setIcon(icon)
        self.ui.boGuardar.setIconSize(QtCore.QSize(32,32))
        self.ui.boGuardar.setDefault(True)
        self.connect(self.ui.boGuardar, QtCore.SIGNAL('clicked()'), self.guarda)

        ## Cancelar
        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Cancel.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.ui.boCancelar.setIcon(icon)
        self.ui.boCancelar.setIconSize(QtCore.QSize(32,32))
        self.connect(self.ui.boCancelar, QtCore.SIGNAL('clicked()'), self.cancela)

        self.connect(session.eventRouter, QtCore.SIGNAL('lugaresChanged()'), self.cargaLugares)

        self.setTabOrder(self.ui.edNombre, self.ui.edApellidos)
        self.setTabOrder(self.ui.edApellidos, self.ui.edRFC)
        self.setTabOrder(self.ui.edRFC, self.ui.edCalle)
        self.setTabOrder(self.ui.edCalle, self.ui.edColonia)
        self.setTabOrder(self.ui.edColonia, self.ui.edCodigoPostal)
        self.setTabOrder(self.ui.edCodigoPostal, self.ui.cbLugar)
        self.setTabOrder(self.ui.cbLugar, self.ui.edTelefonos)
        self.setTabOrder(self.ui.edTelefonos, self.ui.edClasificacion)
        self.setTabOrder(self.ui.edClasificacion, self.ui.cbPuesto1)
        self.setTabOrder(self.ui.cbPuesto1, self.ui.cbPuesto2)
        self.setTabOrder(self.ui.cbPuesto2, self.ui.cbPuesto3)
        self.setTabOrder(self.ui.cbPuesto3, self.ui.edAgentes)
        self.setTabOrder(self.ui.edAgentes, self.ui.edCuentas)
        self.setTabOrder(self.ui.edCuentas, self.ui.taxED)
        self.setTabOrder(self.ui.taxED, self.ui.cargoExtraSiRB)
        self.setTabOrder(self.ui.cargoExtraSiRB, self.ui.cargoExtraNoRB)
        self.setTabOrder(self.ui.cargoExtraNoRB, self.ui.boGuardar)
        self.setTabOrder(self.ui.boGuardar, self.ui.boCancelar)

        self.mensajes = u""

        self.status = 'normal'


    def actualizaStatus(self, *args):
        if self.status==u'normal':
            if self.modo == 'modificar':
                if self.estaModificado():
                    if self.esValida():
                        self.ui.boGuardar.setEnabled(True)
                        self.ui.boGuardar.setToolTip(self.mensajes2)
                        self.ui.comentarios.setText(self.mensajes2)
                    else:
                        self.ui.boGuardar.setEnabled(False)
                        self.ui.boGuardar.setToolTip(self.mensajes)
                        self.ui.comentarios.setText(self.mensajes)
                else:
                    self.ui.boGuardar.setEnabled(False)
                    self.ui.boGuardar.setToolTip(u"No hay cambios")
                    self.ui.comentarios.setText(u"")
            elif self.modo == 'agregar':
                if self.esValida():
                    self.ui.boGuardar.setEnabled(True)
                else:
                    self.ui.boGuardar.setEnabled(False)
                self.ui.boGuardar.setToolTip(self.mensajes)
                self.ui.comentarios.setText(self.mensajes)


    def agrega(self):
        self.ui.titulo.setText(QtGui.QApplication.translate("Empresa Básica", "%s Nuevo" % package.rolTypeS.capitalize(), None, QtGui.QApplication.UnicodeUTF8))
        # self.ui.titulo.setFrameShape(QtGui.QFrame.WinPanel)
        # self.ui.titulo.setFrameShadow(QtGui.QFrame.Sunken)

        self.__modo = 'agregar'
        self.clear()

        self.actualizaStatus()

        self.owner.setInnerStatus('hidden')

        self.ui.edNombre.setFocus()    # Put at the end

        self.show()


    def agregaPuesto(self):
        if self.ui.cbPuesto2.isHidden():
            if self.ui.cbPuesto1.currentText():
                self.ui.cbPuesto2.show()
        elif self.ui.cbPuesto3.isHidden():
            if self.ui.cbPuesto2.currentText():
                self.ui.cbPuesto3.show()
        else:
            result = QtGui.QMessageBox.information(self, u"Empresa Básica - Agregar un puesto", u"Sólo se permiten 3 puestos", QtGui.QMessageBox.Ok, QtGui.QMessageBox.Ok)


    def cancela(self):
        self.clear()
        self.hide()
        self.emit(QtCore.SIGNAL("capturaClosed()"))


    def cargaPuestos(self):
        registros = model.damePuestos()
        self.ui.cbPuesto1.clear()
        self.ui.cbPuesto2.clear()
        self.ui.cbPuesto3.clear()
        for registro in registros:
            self.ui.cbPuesto1.addItem(registro.nombre.capitalize(), QtCore.QVariant(registro.id))
            self.ui.cbPuesto2.addItem(registro.nombre.capitalize(), QtCore.QVariant(registro.id))
            self.ui.cbPuesto3.addItem(registro.nombre.capitalize(), QtCore.QVariant(registro.id))


    def cargaLugares(self):
        registros = model.getLugares()
        self.ui.cbLugar.clear()
        for registro in registros:
            self.ui.cbLugar.addItem(registro['nombre'], QtCore.QVariant(registro['id']))


    def clear(self):
        self.ui.edNombre.setInitialText('', actualToo=True)
        self.ui.edApellidos.clear()
        self.ui.edCalle.clear()
        self.ui.edColonia.clear()
        self.ui.edCodigoPostal.clear()
        self.ui.cbLugar.initialIndex = -1
        self.ui.cbLugar.setCurrentIndex(-1)
        self.ui.edRFC.clear()
        self.ui.edTelefonos.clear()
        self.ui.cbPuesto1.setEditText("")
        self.ui.cbPuesto2.setEditText("")
        self.ui.cbPuesto3.setEditText("")
        self.ui.edClasificacion.clear()
        self.ui.edAgentes.clear()
        self.ui.edCuentas.clear()

        self.mensajes = u""
        self.mensajes2 = u""


    def data(self):
        datos = {}

        if self.old:
            datos['id'] = self.old['id']

        datos['tipo'] = package.rolTypeS
        datos['nombre'] = unicode(self.ui.edNombre.text())
        datos['nombre2'] = unicode(self.ui.edApellidos.text())
        datos['rfc'] = unicode(self.ui.edRFC.text())
        datos['personalidad'] = self.ui.edRFC.tipo()
        datos['calle'] = unicode(self.ui.edCalle.text())
        datos['areanominal']  = unicode(self.ui.edColonia.text())
        datos['areapostal'] = unicode(self.ui.edCodigoPostal.text())

        if self.ui.cbLugar.currentIndex() == -1:
            datos['lugar'] = unicode(self.ui.cbLugar.currentText())
        else:
            datos['lugar_id'] = self.ui.cbLugar.itemData(self.ui.cbLugar.currentIndex()).toInt()[0]

        datos['contactos'] = []
        datos['contactos'].append([u'teléfonoFijo', unicode(self.ui.edTelefonos.text())])

        datos['funciones'] = []
        if self.ui.cbPuesto1.currentText():
            try:
                datos['funciones'].append((self.ui.cbPuesto1.data, unicode(self.ui.cbPuesto1.currentText())))
            except:
                datos['funciones'].append((None, unicode(self.ui.cbPuesto1.currentText())))
        if self.ui.cbPuesto2.currentText():
            try:
                datos['funciones'].append((self.ui.cbPuesto2.data, unicode(self.ui.cbPuesto2.currentText())))
            except:
                datos['funciones'].append((None, unicode(self.ui.cbPuesto2.currentText())))
        if self.ui.cbPuesto3.currentText():
            try:
                datos['funciones'].append((self.ui.cbPuesto3.data, unicode(self.ui.cbPuesto3.currentText())))
            except:
                datos['funciones'].append((None, unicode(self.ui.cbPuesto3.currentText())))

        datos['comentarios'] = unicode(self.ui.edAgentes.text())
        datos['dato2'] = unicode(self.ui.edCuentas.text())
        return datos


    def estaModificado(self):
        data = self.data()
        modificado = False
        self.mensajes2 = u""

        if self.old:
            # if self.old.entidad.nombre != data['nombre']:
                # modificado = True
                # self.mensajes2 += u"Nombre modificado\n"

            if self.old['nombre2'] != data['nombre2']:
                modificado = True
                self.mensajes2 += u"Apellidos modificado\n"

            # if self.old.direcciones:
                # if self.old.direcciones[0].calle != data['calle']:
                    # modificado = True
                    # self.mensajes2 += u"Calle modificada\n"

                # if self.old.direcciones[0].areanominal != data['areanominal']:
                    # modificado = True
                    # self.mensajes2 += u"Colonia modificada\n"

                # if self.old.direcciones[0].areapostal != data['areapostal']:
                    # modificado = True
                    # self.mensajes2 += u"Código postal modificado\n"

                # if self.ui.cbLugar.isModified:
                    # modificado = True
                    # self.mensajes2 += u"Lugar modificado\n"

                # if not (not self.old.direcciones[0].lugar_id and not data['lugar'][1]):
                    # if self.old.direcciones[0].lugar_id != data['lugar'][1]:
                        # modificado = True
                        # self.mensajes2 += u"Lugar modificado\n"
            else:
                if data['calle']:
                    modificado = True
                    self.mensajes2 += u"Calle modificada\n"

                if data['areanominal']:
                    modificado = True
                    self.mensajes2 += u"Colonia modificada\n"

                if data['areapostal']:
                    modificado = True
                    self.mensajes2 += u"Código postal modificado\n"

                # if data['lugar'][1] != -1:
                    # modificado = True
                    # self.mensajes2 += u"Lugar modificado\n"

            if self.old['personalidad'] != data['personalidad']:
                modificado = True
                self.mensajes2 += u"Personalidad modificada\n"

            if self.old['rfc'] != data['rfc']:
                modificado = True
                self.mensajes2 += u"RFC modificado\n"

            if self.ui.edTelefonos.isModified:
                modificado = True
                self.mensajes2 += u"Teléfono modificado\n"
            # if self.old.contactos:
                # if self.old.contactos[0].valor != data['telefonoFijo']:
                    # modificado = True
                    # self.mensajes2 += u"Teléfono modificado\n"
            # else:
                # if data['telefonoFijo']:
                    # modificado = True
                    # self.mensajes2 += u"Teléfono Modificado\n"

            if package.rolType == u'empleados':
                funcionesOld = [x for x in self.old.atributos if x.nombre == u'función']
                if funcionesOld:
                    if data['funciones']:
                        if len(funcionesOld) != len(data['funciones']):
                            modificado = True
                            self.mensajes2 += u'3Modificación en Puestos'
                        pass
                    else:
                        modificado = True
                        self.mensajes2 += u'1Modificación en Puestos'
                else:
                    if data['funciones']:
                        modificado = True
                        self.mensajes2 += u'2Modificación en puestos'

            if not (not self.old['comentarios'] and not data['comentarios']):
                if self.old['comentarios'] != data['comentarios']:
                    modificado = True
                    self.mensajes2 += u"Agente modificado\n"

            if not (not self.old['dato2'] and not data['dato2']):
                if self.old['dato2'] != data['dato2']:
                    modificado = True
                    self.mensajes2 += u"Cuenta modificada\n"

        if self.ui.edNombre.isModified:
            modificado = True
            self.mensajes2 += u"Nombre modificado\n"

        if self.ui.cbLugar.currentIndex() != self.ui.cbLugar.initialIndex:
            modificado = True
            self.mensajes2 += u"Lugar cambiado\n"

        self.mensajes2.rstrip(u"\n")

        if self.mensajes2:
            return True
        else:
            return False


    def esValida(self):
        valida = True
        self.mensajes = ""

        if self.ui.edNombre.isEmpty:
            valida = False
            self.mensajes += u"Falta el nombre\n"
        elif not self.ui.edNombre.isValid:
            valida = False
            self.mensajes += u"%s\n" % self.ui.edNombre.message()

        if not self.ui.edApellidos.isValid:
            valida = False
            self.mensajes += u"%s\n" % self.ui.edApellidos.message()

        if not self.ui.edCalle.isValid:
            valida = False
            self.mensajes += u"%s\n" % self.ui.edCalle.message()

        if not self.ui.edColonia.isValid:
            valida = False
            self.mensajes += u"%s\n" % self.ui.edColonia.message()

        if not self.ui.edCodigoPostal.isValid:
            valida = False
            self.mensajes += u"%s\n" % self.ui.edCodigoPostal.message()

        # if not self.ui.edLugar.isValid:
            # valida = False
            # self.mensajes += u"%s\n" % self.ui.edLugar.message()

        if not self.ui.edRFC.isValid:
            valida = False
            if self.ui.edRFC.text() == "":
                self.mensajes += u"Falta el RFC\n"
            else:
                self.mensajes += u"Error en el RFC\n%s\n" % self.ui.edRFC.message()

        if not self.ui.edTelefonos.isValid:
            valida = False
            self.mensajes += u"%s\n" % self.ui.edTelefonos.message()

        if package.rolType == u'proveedores':
            if not self.ui.edAgentes.isValid:
                valida = False
                self.mensajes += u"%s\n" % self.ui.edAgentes.message()

        elif package.rolType == u'empleados':
            if not self.ui.cbPuesto1.currentText():
                valida = False
                self.mensajes += u"Falta seleccionar el puesto\n"

        elif package.rolType == u'clientes':
            if not self.ui.edAgentes.isValid:
                valida = False
                self.mensajes += u"%s\n" % self.ui.edAgentes.message()

        self.mensajes = self.mensajes.rstrip("\n")

        return valida


    def guarda(self):
        ## No se revisa validez de datos, para llegar aquí se tuvo que haber hecho

        self.setCursor(QtCore.Qt.WaitCursor)
        data = self.data()

        lugarNuevo = not 'lugar_id' in data.keys()

        if self.modo == 'agregar':
            model.addPerson(data)

        elif self.modo == 'modificar':
            model.addPerson(data)

        session.eventRouter.emit(QtCore.SIGNAL('%sChanged()' % package.rolType))

        if lugarNuevo:
            session.eventRouter.emit(QtCore.SIGNAL("lugaresChanged()"))

        self.hide()

        self.emit(QtCore.SIGNAL("capturaClosed()"))

        self.setCursor(QtCore.Qt.ArrowCursor)


    def lugarChanged(self):
        self.actualizaStatus()


    def lugarEdited(self):
        if self.ui.cbLugar.findText(self.ui.cbLugar.currentText(), QtCore.Qt.MatchStartsWith) == -1:
            self.ui.cbLugar.setStyleSheet("background-color:#FFFF60;")
        else:
            self.ui.cbLugar.setStyleSheet("background-color:#FFFFFF;")

        self.actualizaStatus()


    def lugarLostFocus(self):
        if self.ui.cbLugar.findText(self.ui.cbLugar.currentText(), QtCore.Qt.MatchStartsWith) == -1:
            self.ui.cbLugar.setStyleSheet("background-color:#FFFF60;")
        else:
            self.ui.cbLugar.setStyleSheet("background-color:#FFFFFF;")
            self.ui.cbLugar.setCurrentIndex(self.ui.cbLugar.findText(self.ui.cbLugar.currentText(), QtCore.Qt.MatchStartsWith))
        self.actualizaStatus()


    def modifica(self, id):
        self.ui.titulo.setText(u"Modificación de %s" % package.rolTypeS)

        self.__modo = 'modificar'
        self.clear()

        data = model.getFullRol(id=id)

        self.setData(data)

        self.actualizaStatus()

        self.owner.setInnerStatus('hidden')

        self.ui.edNombre.setFocus()    # Put at the end

        self.show()


    # def muestraPuestos(self):
        # self.ui.edPuesto.completer().setCompletionPrefix(self.ui.edPuesto.text())
        # self.ui.edPuesto.completer().complete()


    def nombreEditado(self, texto):
        self.revisaRFC()


    def nombre2Editado(self, texto):
        self.revisaRFC()


    # def puestoGotFocus(self):
        # self.ui.edPuesto.completer().complete()


    def puestoSeleccionado(self, completerModelIndex):
        m = "personas.vista.Captura.puestoSelecionado()"

        self.actualizaStatus()


    def returnPressed(self):
        if self.ui.boGuardar.isEnabled():
            self.guarda()


    def revisaRFC(self, *args):
        if self.ui.edApellidos.text():
            self.ui.edRFC.setTipo(CDRfcEdit.FISICA)
        else:
            self.ui.edRFC.setTipo(CDRfcEdit.MORAL)
        self.ui.edRFC.setExternalValidation(True, u"")
        if self.ui.edRFC.isValid:
            rol = model.getRol(tipo=package.rolTypeS, rfc=unicode(self.ui.edRFC.text()))
            if rol:
                if self.modo == 'modificar' and rol['id'] == self.old['id']:
                    pass
                else:
                    self.ui.edRFC.setExternalValidation(False, u"Ya existe un %s con este RFC" % package.rolTypeS)
            else:
                rol = model.getRol(rfc=unicode(self.ui.edRFC.text()))
                if rol:
                    if self.modo == 'modificar':
                        if rol['id'] != self.old['id']:
                            self.ui.edRFC.setExternalValidation(False, u"Ya existe una persona con este RFC")

        self.actualizaStatus()


    def setData(self, rol):
        self.old = rol
        self.ui.edNombre.setInitialText(rol['nombre'], currentToo=True)

        self.ui.edApellidos.setText(rol['nombre2'])

        self.ui.edRFC.setText(rol['rfc'])
        self.revisaRFC()

        ## Direcciones
        if rol['addresses']:
            if not rol['addresses'][0]['calle']:
                self.ui.edCalle.setText(u"")
            else:
                self.ui.edCalle.setText(rol['addresses'][0]['calle'])
            self.ui.edColonia.setText(rol['addresses'][0]['areanominal'])
            self.ui.edCodigoPostal.setText(rol['addresses'][0]['areapostal'])
            self.ui.cbLugar.initialIndex = self.ui.cbLugar.findData(QtCore.QVariant(rol['addresses'][0]['lugar_id']))
            self.ui.cbLugar.setCurrentIndex(self.ui.cbLugar.initialIndex)

        ## Contactos
        if rol['telefonos']:
            self.ui.edTelefonos.setText("check")
        else:
            self.ui.edTelefonos.setText(u"")

        ## Funciones
        if rol['funcion']:
            self.ui.cbPuesto1.setEditText(rol['funcion'])
        else:
            self.ui.cbPuesto1.setEditText("")
        #~ funciones = model.rolAttributes(rol_id=rol['id'], nombre=u'función')
        #~ if len(funciones) > 0:
            #~ funcion = funciones[0]
            #~ self.ui.cbPuesto1.setEditText(funcion['valor'])
            #~ self.ui.cbPuesto1.data = funcion['id']
        #~ if len(funciones) > 1:
            #~ funcion = funciones[1]
            #~ self.ui.cbPuesto2.setEditText(funcion['valor'])
            #~ self.ui.cbPuesto2.data = funcion['id']
            #~ self.ui.cbPuesto2.show()
        #~ else:
            #~ self.ui.cbPuesto2.hide()
        #~ if len(funciones) > 2:
            #~ funcion = funciones[2]
            #~ self.ui.cbPuesto3.setEditText(funcion['valor'])
            #~ self.ui.cbPuesto3.data = funcion['id']
            #~ self.ui.cbPuesto3.show()
        #~ else:
            #~ self.ui.cbPuesto3.hide()

        if not rol['comentarios']:
            self.ui.edAgentes.setText(u'')
        else:
            self.ui.edAgentes.setText(rol['comentarios'])

        if rol['dato2']:
            self.ui.edCuentas.setText(rol['dato2'])


    def toggleComentarios(self):
        if self.ui.boComentarios.status==u'on':
            self.ui.comentarios.hide()
            self.ui.boComentarios.status=u'off'
            self.ui.boComentarios.setText(u'Mostrar información')
        else:
            self.ui.comentarios.show()
            self.ui.boComentarios.status=u'on'
            self.ui.boComentarios.setText(u'Ocultar información')



class Detalles(QtGui.QFrame):

    def __init__(self, *args):
        self.owner = args[0]

        QtGui.QFrame.__init__(self, *args)

        self.ui = detalles_ui.Ui_Form()
        self.ui.setupUi(self)

        font = QtGui.QFont()
        font.setPointSize(10)
        font.setWeight(75)
        font.setBold(True)

        self.ui.laNombre.setFont(font)

        if package.rolType == u'proveedores':
            self.connect(session.eventRouter, QtCore.SIGNAL("proveedoresChanged()"), self.actualiza)
        if package.rolType == u'empleados':
            self.connect(session.eventRouter, QtCore.SIGNAL("empleadosChanged()"), self.actualiza)
        if package.rolType == u'clientes':
            self.connect(session.eventRouter, QtCore.SIGNAL("clientesChanged()"), self.actualiza)

        self.id = None


    def actualiza(self):           # print "personas.vista.Detalles.actualiza()"
        if self.id:
            rol = model.rol(id=self.id)
            self.setData(rol)


    def mostrar(self, id):
        rol = model.rol(id=id)
        self.setData(rol)
        self.show()


    def setData(self, rol):       # print "personas.vista.Detalles.setData()"
        self.id = rol['id']
        self.ui.laNombre.setText("%s %s" % (rol['nombre'], rol['nombre2']))
        if not rol['rfc']:
            self.ui.laRFC.setText(u'RFC:')
        else:
            self.ui.laRFC.setText(u'RFC: <b>%s</b>' % rol['rfc'])

        ## Direcciones
        direcciones = model.addresses(rol_id=rol['id'])
        if direcciones:
            self.ui.laCalle.setText(u"Calle: <b>%s</b>" % direcciones[0]['calle'])
            self.ui.laColonia.setText(u"<b>%s</b>" % direcciones[0]['areanominal'])
            self.ui.laCodigoPostal.setText(u"<b>%s</b>" % direcciones[0]['areapostal'])
            self.ui.laLugar.setText("<b>%s</b>" % direcciones[0]['lugar'])

        ## Contactos
        telFijo = model.rolAttributes(rol_id=rol['id'], nombre=u'tel fijo')
        if telFijo:
            self.ui.laTelefonos.setText("Tels: <b>%s</b>" % telFijo['valor'])

        if not rol['comentarios']:
            self.ui.laAgentes.setText(u'')
        else:
            self.ui.laAgentes.setText("Agente: <b>%s</b>" % rol['comentarios'])


class Splitter(QtGui.QSplitter):

    def __init__(self, *args):
        self.orientation = args[0]
        QtGui.QSplitter.__init__(self, *args)

    def createHandle(self):
        return Handle(self.orientation, self)



class Handle(QtGui.QSplitterHandle):

    def __init__(self, *args):
        QtGui.QSplitterHandle.__init__(self, *args)

    def mouseDoubleClickEvent(self, event):
        self.emit(QtCore.SIGNAL("handlePressed"))



class Modelo(QtCore.QAbstractListModel):

    def __init__(self, *args):
        f=g

        QtCore.QAbstractListModel.__init__(self, *args)
        self.__data = []

    def clear(self):
        self.beginRemoveRows(QtCore.QModelIndex(), 0, self.rowCount())
        self.__data = []
        self.endRemoveRows()

    def data(self, index, role=QtCore.Qt.DisplayRole):
        if index.row() != -1:
            if role in [QtCore.Qt.DisplayRole]:
                return self.__data[index.row()][0]
            elif role in [QtCore.Qt.EditRole]:
                return self.__data[index.row()][1]
            elif role == QtCore.Qt.TextAlignmentRole:
                return QtCore.QVariant(int(QtCore.Qt.AlignLeft|QtCore.Qt.AlignVCenter))
            elif role == QtCore.Qt.UserRole:
                return self.__data[index.row()][2]
        return QtCore.QVariant()

    def insertRow(self, row, parent=QtCore.QModelIndex()):
        self.__data.insert(row, [QtCore.QVariant(u""), QtCore.QVariant(u""), QtCore.QVariant(u"")])
        return True

    def rowCount(self, parent=QtCore.QModelIndex()):
        return len(self.__data)

    def reload(self):
        pass

    def setData(self, index, valor, role=QtCore.Qt.DisplayRole):
        if role == QtCore.Qt.DisplayRole:
            self.__data[index.row()][0] = QtCore.QVariant(valor)
        elif role == QtCore.Qt.EditRole:
            self.__data[index.row()][1] = QtCore.QVariant(valor)
        elif role == QtCore.Qt.UserRole:
            self.__data[index.row()][2] = QtCore.QVariant(valor)
        else:
            print 12345, role
        return True

